home *** CD-ROM | disk | FTP | other *** search
/ Champak 49 / Volume 49 - JOGO DISK .iso / Games / gasmania.swf / scripts / DefineSprite_313 / frame_15 / DoAction.as
Encoding:
Text File  |  2007-10-01  |  55.6 KB  |  1,131 lines

  1. var ┬º\x01┬º = 972;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 972)
  6.    {
  7.       set("\x01",eval("\x01") - 674);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 396)
  12.    {
  13.       set("\x01",eval("\x01") + 423);
  14.       if(┬º┬ºpop())
  15.       {
  16.          set("\x01",eval("\x01") - 537);
  17.       }
  18.       continue;
  19.    }
  20.    if(eval("\x01") == 909)
  21.    {
  22.       set("\x01",eval("\x01") - 249);
  23.       ┬º┬ºpush(true);
  24.       continue;
  25.    }
  26.    if(eval("\x01") == 705)
  27.    {
  28.       set("\x01",eval("\x01") + 23);
  29.       continue;
  30.    }
  31.    if(eval("\x01") == 819)
  32.    {
  33.       set("\x01",eval("\x01") - 537);
  34.       ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  35.       trace(┬º┬ºpop());
  36.       while(true)
  37.       {
  38.          if(eval(┬º┬ºpop()) == 845)
  39.          {
  40.             set("\x01",eval("\x01") - 559);
  41.          }
  42.          else if(eval("\x01") == 957)
  43.          {
  44.             set("\x01",eval("\x01") - 533);
  45.          }
  46.          else
  47.          {
  48.             if(eval("\x01") == 956)
  49.             {
  50.                set("\x01",eval("\x01") - 551);
  51.                loop8:
  52.                while(true)
  53.                {
  54.                   if(┬º┬ºpop() == ┬º┬ºpop())
  55.                   {
  56.                      set("\x01",eval("\x01") + 308);
  57.                      addr776:
  58.                      ┬º┬ºpush(true);
  59.                      while(true)
  60.                      {
  61.                         if(eval("\x01") == 735)
  62.                         {
  63.                            set("\x01",eval("\x01") - 590);
  64.                            ┬º┬ºpush(true);
  65.                            continue;
  66.                         }
  67.                         if(eval("\x01") == 887)
  68.                         {
  69.                            set("\x01",eval("\x01") + 87);
  70.                            gotoAndStop(56608);
  71.                            break loop0;
  72.                         }
  73.                         if(eval("\x01") == 494)
  74.                         {
  75.                            set("\x01",eval("\x01") - 319);
  76.                            ┬º┬ºpush(true);
  77.                            continue;
  78.                         }
  79.                         if(eval("\x01") == 902)
  80.                         {
  81.                            set("\x01",eval("\x01") - 637);
  82.                            continue;
  83.                         }
  84.                         if(eval("\x01") == 670)
  85.                         {
  86.                            set("\x01",eval("\x01") + 232);
  87.                            ┬º┬ºpush({});
  88.                            break loop0;
  89.                         }
  90.                         if(eval("\x01") == 974)
  91.                         {
  92.                            set("\x01",eval("\x01") - 80);
  93.                            continue;
  94.                         }
  95.                         if(eval("\x01") == 500)
  96.                         {
  97.                            set("\x01",eval("\x01") - 230);
  98.                            ┬º┬ºpush(true);
  99.                            continue;
  100.                         }
  101.                         if(eval("\x01") == 755)
  102.                         {
  103.                            set("\x01",eval("\x01") - 641);
  104.                            continue;
  105.                         }
  106.                         if(eval("\x01") == 83)
  107.                         {
  108.                            set("\x01",eval("\x01") + 685);
  109.                            continue;
  110.                         }
  111.                         ┬º┬ºpush(eval("\x01"));
  112.                         ┬º┬ºpush(476);
  113.                         continue loop8;
  114.                      }
  115.                      addr776:
  116.                   }
  117.                   else if(eval("\x01") == 739)
  118.                   {
  119.                      set("\x01",eval("\x01") - 551);
  120.                      if(┬º┬ºpop())
  121.                      {
  122.                         set("\x01",eval("\x01") - 133);
  123.                      }
  124.                      ┬º┬ºgoto(addr776);
  125.                   }
  126.                   else if(eval("\x01") == 145)
  127.                   {
  128.                      set("\x01",eval("\x01") + 742);
  129.                      if(┬º┬ºpop())
  130.                      {
  131.                         set("\x01",eval("\x01") + 87);
  132.                      }
  133.                      ┬º┬ºgoto(addr776);
  134.                   }
  135.                   else if(eval("\x01") == 7)
  136.                   {
  137.                      set("\x01",eval("\x01") + 469);
  138.                      ┬º┬ºgoto(addr776);
  139.                   }
  140.                   else if(eval("\x01") == 132)
  141.                   {
  142.                      set("\x01",eval("\x01") + 762);
  143.                      ┬º┬ºgoto(addr776);
  144.                   }
  145.                   else if(eval("\x01") == 894)
  146.                   {
  147.                      set("\x01",eval("\x01") - 155);
  148.                      ┬º┬ºgoto(addr776);
  149.                      ┬º┬ºpush(true);
  150.                   }
  151.                   else
  152.                   {
  153.                      if(eval("\x01") == 10)
  154.                      {
  155.                         set("\x01",eval("\x01") + 449);
  156.                         if(┬º┬ºpop())
  157.                         {
  158.                            set("\x01",eval("\x01") - 376);
  159.                         }
  160.                      }
  161.                      else
  162.                      {
  163.                         if(eval("\x01") == 853)
  164.                         {
  165.                            set("\x01",eval("\x01") + 123);
  166.                            break loop0;
  167.                         }
  168.                         if(eval("\x01") == 318)
  169.                         {
  170.                            set("\x01",eval("\x01") + 182);
  171.                         }
  172.                         else
  173.                         {
  174.                            if(eval("\x01") != 629)
  175.                            {
  176.                               if(eval("\x01") == 359)
  177.                               {
  178.                                  set("\x01",eval("\x01") + 396);
  179.                                  break loop0;
  180.                               }
  181.                               if(eval("\x01") == 920)
  182.                               {
  183.                                  addr1087:
  184.                                  ┬º┬ºpush("\x01");
  185.                                  ┬º┬ºpush("\x01");
  186.                                  while(true)
  187.                                  {
  188.                                     set(┬º┬ºpop(),eval(┬º┬ºpop()) - 426);
  189.                                     ┬º┬ºgoto(addr776);
  190.                                     ┬º┬ºgoto(addr1087);
  191.                                  }
  192.                                  addr1089:
  193.                               }
  194.                               else if(eval("\x01") == 805 ? (set("\x01",eval("\x01") + 81), new ┬º\┬º\┬ºpop()┬º()) : eval("\x01") == 175)
  195.                               {
  196.                                  set("\x01",eval("\x01") + 519);
  197.                                  if(┬º┬ºpop())
  198.                                  {
  199.                                     set("\x01",eval("\x01") - 224);
  200.                                  }
  201.                                  ┬º┬ºgoto(addr776);
  202.                               }
  203.                               else
  204.                               {
  205.                                  if(eval("\x01") == 188)
  206.                                  {
  207.                                     set("\x01",eval("\x01") - 133);
  208.                                     break loop0;
  209.                                  }
  210.                                  if(eval("\x01") == 855)
  211.                                  {
  212.                                     set("\x01",eval("\x01") - 361);
  213.                                     ┬º┬ºgoto(addr776);
  214.                                  }
  215.                                  else if(eval("\x01") == 768)
  216.                                  {
  217.                                     set("\x01",eval("\x01") - 767);
  218.                                     ┬º┬ºgoto(addr776);
  219.                                     ┬º┬ºpush(true);
  220.                                  }
  221.                                  else if(eval("\x01") != 941)
  222.                                  {
  223.                                     if(eval("\x01") == 1)
  224.                                     {
  225.                                        set("\x01",eval("\x01") + 669);
  226.                                        if(┬º┬ºpop())
  227.                                        {
  228.                                           set("\x01",eval("\x01") + 232);
  229.                                        }
  230.                                     }
  231.                                     else if(eval("\x01") == 588)
  232.                                     {
  233.                                        set("\x01",eval("\x01") - 323);
  234.                                     }
  235.                                     else
  236.                                     {
  237.                                        if(eval("\x01") != 32)
  238.                                        {
  239.                                           if(eval("\x01") == 161)
  240.                                           {
  241.                                              set("\x01",eval("\x01") + 694);
  242.                                              while(true)
  243.                                              {
  244.                                                 if(!┬º┬ºpop())
  245.                                                 {
  246.                                                    set("\x01",eval("\x01") - 777);
  247.                                                    if(┬º┬ºpop())
  248.                                                    {
  249.                                                       set("\x01",eval("\x01") + 38);
  250.                                                    }
  251.                                                 }
  252.                                                 else if(eval("\x01") == 863)
  253.                                                 {
  254.                                                    set("\x01",eval("\x01") - 414);
  255.                                                    ┬º┬ºpush(true);
  256.                                                 }
  257.                                                 else if(eval("\x01") == 132)
  258.                                                 {
  259.                                                    set("\x01",eval("\x01") + 655);
  260.                                                    ┬º┬ºpush(true);
  261.                                                 }
  262.                                                 else
  263.                                                 {
  264.                                                    if(eval("\x01") == 210)
  265.                                                    {
  266.                                                       set("\x01",eval("\x01") + 187);
  267.                                                       break loop0;
  268.                                                    }
  269.                                                    if(eval("\x01") == 789)
  270.                                                    {
  271.                                                       set("\x01",eval("\x01") - 566);
  272.                                                    }
  273.                                                    else
  274.                                                    {
  275.                                                       if(eval("\x01") == 753)
  276.                                                       {
  277.                                                          set("\x01",eval("\x01") - 491);
  278.                                                          break loop0;
  279.                                                       }
  280.                                                       if(eval("\x01") == 397)
  281.                                                       {
  282.                                                          set("\x01",eval("\x01") - 142);
  283.                                                       }
  284.                                                       else if(eval("\x01") == 805)
  285.                                                       {
  286.                                                          set("\x01",eval("\x01") + 58);
  287.                                                       }
  288.                                                       else if(eval("\x01") == 465)
  289.                                                       {
  290.                                                          set("\x01",eval("\x01") - 333);
  291.                                                       }
  292.                                                       else if(eval("\x01") == 382)
  293.                                                       {
  294.                                                          set("\x01",eval("\x01") + 536);
  295.                                                       }
  296.                                                       else if(eval("\x01") == 420)
  297.                                                       {
  298.                                                          set("\x01",eval("\x01") + 39);
  299.                                                       }
  300.                                                       else if(eval("\x01") == 157)
  301.                                                       {
  302.                                                          set("\x01",eval("\x01") - 48);
  303.                                                       }
  304.                                                       else if(eval("\x01") == 262)
  305.                                                       {
  306.                                                          set("\x01",eval("\x01") + 487);
  307.                                                       }
  308.                                                       else if(eval("\x01") == 449)
  309.                                                       {
  310.                                                          set("\x01",eval("\x01") + 160);
  311.                                                          if(┬º┬ºpop())
  312.                                                          {
  313.                                                             set("\x01",eval("\x01") - 84);
  314.                                                          }
  315.                                                       }
  316.                                                       else
  317.                                                       {
  318.                                                          if(eval("\x01") == 937)
  319.                                                          {
  320.                                                             set("\x01",eval("\x01") - 132);
  321.                                                             break loop0;
  322.                                                          }
  323.                                                          if(eval("\x01") == 242)
  324.                                                          {
  325.                                                             set("\x01",eval("\x01") - 110);
  326.                                                          }
  327.                                                          else if(eval("\x01") == 874)
  328.                                                          {
  329.                                                             set("\x01",eval("\x01") + 103);
  330.                                                             if(┬º┬ºpop())
  331.                                                             {
  332.                                                                set("\x01",eval("\x01") - 735);
  333.                                                             }
  334.                                                          }
  335.                                                          else
  336.                                                          {
  337.                                                             if(eval("\x01") == 713)
  338.                                                             {
  339.                                                                set("\x01",eval("\x01") - 635);
  340.                                                                break loop0;
  341.                                                             }
  342.                                                             if(eval("\x01") == 627)
  343.                                                             {
  344.                                                                set("\x01",eval("\x01") - 417);
  345.                                                                if(┬º┬ºpop())
  346.                                                                {
  347.                                                                   set("\x01",eval("\x01") + 187);
  348.                                                                }
  349.                                                             }
  350.                                                             else if(eval("\x01") == 199)
  351.                                                             {
  352.                                                                set("\x01",eval("\x01") + 532);
  353.                                                             }
  354.                                                             else if(eval("\x01") == 731)
  355.                                                             {
  356.                                                                set("\x01",eval("\x01") + 143);
  357.                                                                ┬º┬ºpush(true);
  358.                                                             }
  359.                                                             else
  360.                                                             {
  361.                                                                if(eval("\x01") == 977)
  362.                                                                {
  363.                                                                   set("\x01",eval("\x01") - 735);
  364.                                                                   break loop0;
  365.                                                                }
  366.                                                                if(eval("\x01") == 787)
  367.                                                                {
  368.                                                                   set("\x01",eval("\x01") - 74);
  369.                                                                   if(┬º┬ºpop())
  370.                                                                   {
  371.                                                                      set("\x01",eval("\x01") - 635);
  372.                                                                   }
  373.                                                                }
  374.                                                                else
  375.                                                                {
  376.                                                                   if(eval("\x01") != 78)
  377.                                                                   {
  378.                                                                      if(eval("\x01") == 109)
  379.                                                                      {
  380.                                                                         set("\x01",eval("\x01") + 157);
  381.                                                                         stop();
  382.                                                                         gotoAndPlay(2);
  383.                                                                         delete this.onEnterFrame;
  384.                                                                         break loop0;
  385.                                                                      }
  386.                                                                      if(eval("\x01") == 266)
  387.                                                                      {
  388.                                                                         set("\x01",eval("\x01") - 266);
  389.                                                                      }
  390.                                                                      break loop0;
  391.                                                                   }
  392.                                                                   set("\x01",eval("\x01") + 31);
  393.                                                                }
  394.                                                             }
  395.                                                          }
  396.                                                       }
  397.                                                    }
  398.                                                 }
  399.                                                 loop4:
  400.                                                 while(true)
  401.                                                 {
  402.                                                    if(eval("\x01") == 584)
  403.                                                    {
  404.                                                       set("\x01",eval("\x01") + 324);
  405.                                                       ┬º┬ºpush(true);
  406.                                                       continue;
  407.                                                    }
  408.                                                    if(eval("\x01") == 881)
  409.                                                    {
  410.                                                       set("\x01",eval("\x01") - 346);
  411.                                                       stop();
  412.                                                       break loop0;
  413.                                                    }
  414.                                                    if(eval("\x01") == 918)
  415.                                                    {
  416.                                                       set("\x01",eval("\x01") + 20);
  417.                                                       ┬º┬ºpush(true);
  418.                                                       continue;
  419.                                                    }
  420.                                                    if(eval("\x01") == 712)
  421.                                                    {
  422.                                                       set("\x01",eval("\x01") + 41);
  423.                                                       if(┬º┬ºpop())
  424.                                                       {
  425.                                                          set("\x01",eval("\x01") - 491);
  426.                                                       }
  427.                                                       continue;
  428.                                                    }
  429.                                                    if(eval("\x01") == 518)
  430.                                                    {
  431.                                                       set("\x01",eval("\x01") + 345);
  432.                                                       continue;
  433.                                                    }
  434.                                                    if(eval("\x01") == 459)
  435.                                                    {
  436.                                                       set("\x01",eval("\x01") + 168);
  437.                                                       ┬º┬ºpush(true);
  438.                                                       continue;
  439.                                                    }
  440.                                                    if(eval("\x01") == 161)
  441.                                                    {
  442.                                                       set("\x01",eval("\x01") + 38);
  443.                                                       break loop0;
  444.                                                    }
  445.                                                    if(eval("\x01") == 842)
  446.                                                    {
  447.                                                       set("\x01",eval("\x01") - 111);
  448.                                                       continue;
  449.                                                    }
  450.                                                    if(eval("\x01") == 88)
  451.                                                    {
  452.                                                       set("\x01",eval("\x01") + 661);
  453.                                                       continue;
  454.                                                    }
  455.                                                    if(eval("\x01") == 572)
  456.                                                    {
  457.                                                       set("\x01",eval("\x01") + 309);
  458.                                                       if(┬º┬ºpop())
  459.                                                       {
  460.                                                          set("\x01",eval("\x01") - 346);
  461.                                                       }
  462.                                                       continue;
  463.                                                    }
  464.                                                    if(eval("\x01") == 749)
  465.                                                    {
  466.                                                       set("\x01",eval("\x01") - 177);
  467.                                                       ┬º┬ºpush(true);
  468.                                                       continue;
  469.                                                    }
  470.                                                    if(eval("\x01") == 525)
  471.                                                    {
  472.                                                       set("\x01",eval("\x01") - 302);
  473.                                                       continue;
  474.                                                    }
  475.                                                    if(eval("\x01") == 255)
  476.                                                    {
  477.                                                       set("\x01",eval("\x01") + 296);
  478.                                                       ┬º┬ºpush(true);
  479.                                                       continue;
  480.                                                    }
  481.                                                    if(eval("\x01") == 535)
  482.                                                    {
  483.                                                       set("\x01",eval("\x01") - 76);
  484.                                                       continue;
  485.                                                    }
  486.                                                    if(eval("\x01") == 687)
  487.                                                    {
  488.                                                       set("\x01",eval("\x01") - 432);
  489.                                                       continue;
  490.                                                    }
  491.                                                    if(eval("\x01") == 908)
  492.                                                    {
  493.                                                       set("\x01",eval("\x01") + 29);
  494.                                                       if(┬º┬ºpop())
  495.                                                       {
  496.                                                          set("\x01",eval("\x01") - 132);
  497.                                                       }
  498.                                                       continue;
  499.                                                    }
  500.                                                    if(eval("\x01") == 609)
  501.                                                    {
  502.                                                       ┬º┬ºpush("\x01");
  503.                                                    }
  504.                                                    else
  505.                                                    {
  506.                                                       while(true)
  507.                                                       {
  508.                                                          if(eval("\x01") == 551)
  509.                                                          {
  510.                                                             set("\x01",eval("\x01") + 373);
  511.                                                             if(┬º┬ºpop())
  512.                                                             {
  513.                                                                set("\x01",eval("\x01") - 365);
  514.                                                             }
  515.                                                          }
  516.                                                          else
  517.                                                          {
  518.                                                             if(eval("\x01") == 924)
  519.                                                             {
  520.                                                                set("\x01",eval("\x01") - 365);
  521.                                                                break loop0;
  522.                                                             }
  523.                                                             if(eval("\x01") == 559)
  524.                                                             {
  525.                                                                set("\x01",eval("\x01") + 359);
  526.                                                             }
  527.                                                             else
  528.                                                             {
  529.                                                                if(eval("\x01") != 223)
  530.                                                                {
  531.                                                                   break loop4;
  532.                                                                }
  533.                                                                set("\x01",eval("\x01") + 489);
  534.                                                                ┬º┬ºpush(true);
  535.                                                             }
  536.                                                          }
  537.                                                          continue loop4;
  538.                                                       }
  539.                                                       addr304:
  540.                                                    }
  541.                                                 }
  542.                                              }
  543.                                           }
  544.                                           else
  545.                                           {
  546.                                              if(eval("\x01") == 270)
  547.                                              {
  548.                                                 set("\x01",eval("\x01") - 109);
  549.                                                 if(┬º┬ºpop())
  550.                                                 {
  551.                                                    set("\x01",eval("\x01") + 694);
  552.                                                 }
  553.                                              }
  554.                                              else if(eval("\x01") == 265)
  555.                                              {
  556.                                                 set("\x01",eval("\x01") + 47);
  557.                                                 ┬º┬ºgoto(addr776);
  558.                                                 ┬º┬ºpush(true);
  559.                                              }
  560.                                              else
  561.                                              {
  562.                                                 if(eval("\x01") == 55)
  563.                                                 {
  564.                                                    set("\x01",eval("\x01") + 445);
  565.                                                 }
  566.                                                 else if(eval("\x01") == 607)
  567.                                                 {
  568.                                                    set("\x01",eval("\x01") - 101);
  569.                                                 }
  570.                                                 else
  571.                                                 {
  572.                                                    if(eval("\x01") == 694)
  573.                                                    {
  574.                                                       set("\x01",eval("\x01") - 224);
  575.                                                       break loop0;
  576.                                                    }
  577.                                                    if(eval("\x01") == 312)
  578.                                                    {
  579.                                                       set("\x01",eval("\x01") - 9);
  580.                                                       if(┬º┬ºpop())
  581.                                                       {
  582.                                                          set("\x01",eval("\x01") + 94);
  583.                                                       }
  584.                                                       ┬º┬ºgoto(addr776);
  585.                                                    }
  586.                                                    else if(eval("\x01") == 303)
  587.                                                    {
  588.                                                       set("\x01",eval("\x01") + 94);
  589.                                                    }
  590.                                                    else
  591.                                                    {
  592.                                                       if(eval("\x01") == 470)
  593.                                                       {
  594.                                                          set("\x01",eval("\x01") + 36);
  595.                                                       }
  596.                                                       else if(eval("\x01") == 506)
  597.                                                       {
  598.                                                          set("\x01",eval("\x01") - 496);
  599.                                                          ┬º┬ºgoto(addr776);
  600.                                                          ┬º┬ºpush(true);
  601.                                                       }
  602.                                                       else
  603.                                                       {
  604.                                                          if(eval("\x01") == 459)
  605.                                                          {
  606.                                                             set("\x01",eval("\x01") - 376);
  607.                                                             break loop0;
  608.                                                          }
  609.                                                          if(eval("\x01") == 21)
  610.                                                          {
  611.                                                             set("\x01",eval("\x01") + 920);
  612.                                                          }
  613.                                                          else if(eval("\x01") == 965)
  614.                                                          {
  615.                                                             set("\x01",eval("\x01") - 197);
  616.                                                          }
  617.                                                          else if(eval("\x01") == 397)
  618.                                                          {
  619.                                                             addr1440:
  620.                                                             ┬º┬ºpush("\x01");
  621.                                                             ┬º┬ºpush(eval("\x01") + 443);
  622.                                                             while(true)
  623.                                                             {
  624.                                                                set(┬º┬ºpop(),┬º┬ºpop());
  625.                                                                ┬º┬ºgoto(addr776);
  626.                                                             }
  627.                                                             addr1440:
  628.                                                          }
  629.                                                          else
  630.                                                          {
  631.                                                             if(eval("\x01") == 674)
  632.                                                             {
  633.                                                                set("\x01",eval("\x01") + 166);
  634.                                                             }
  635.                                                             else if(eval("\x01") == 840)
  636.                                                             {
  637.                                                                set("\x01",eval("\x01") - 211);
  638.                                                                ┬º┬ºgoto(addr776);
  639.                                                                ┬º┬ºpush(true);
  640.                                                             }
  641.                                                             else
  642.                                                             {
  643.                                                                if(eval("\x01") == 314)
  644.                                                                {
  645.                                                                   set("\x01",eval("\x01") - 200);
  646.                                                                }
  647.                                                                else if(eval("\x01") == 976)
  648.                                                                {
  649.                                                                   set("\x01",eval("\x01") - 500);
  650.                                                                }
  651.                                                                else if(eval("\x01") == 784)
  652.                                                                {
  653.                                                                   set("\x01",eval("\x01") - 425);
  654.                                                                   if(┬º┬ºpop())
  655.                                                                   {
  656.                                                                      set("\x01",eval("\x01") + 396);
  657.                                                                   }
  658.                                                                }
  659.                                                                else if(eval("\x01") == 114)
  660.                                                                {
  661.                                                                   set("\x01",eval("\x01") - 82);
  662.                                                                   ┬º┬ºgoto(addr776);
  663.                                                                   ┬º┬ºpush(true);
  664.                                                                }
  665.                                                                else
  666.                                                                {
  667.                                                                   if(eval("\x01") != 886)
  668.                                                                   {
  669.                                                                      if(eval("\x01") == 935)
  670.                                                                      {
  671.                                                                         set("\x01",eval("\x01") - 935);
  672.                                                                      }
  673.                                                                      break loop0;
  674.                                                                   }
  675.                                                                   set("\x01",eval("\x01") + 55);
  676.                                                                   ┬º┬ºgoto(addr776);
  677.                                                                }
  678.                                                                ┬º┬ºgoto(addr776);
  679.                                                             }
  680.                                                             ┬º┬ºgoto(addr776);
  681.                                                          }
  682.                                                          ┬º┬ºgoto(addr776);
  683.                                                       }
  684.                                                       ┬º┬ºgoto(addr776);
  685.                                                    }
  686.                                                 }
  687.                                                 ┬º┬ºgoto(addr776);
  688.                                              }
  689.                                              ┬º┬ºgoto(addr776);
  690.                                           }
  691.                                           addr298:
  692.                                           set(┬º┬ºpop(),eval("\x01") - 84);
  693.                                           break loop0;
  694.                                        }
  695.                                        set("\x01",eval("\x01") + 773);
  696.                                        if(┬º┬ºpop())
  697.                                        {
  698.                                           set("\x01",eval("\x01") + 81);
  699.                                        }
  700.                                     }
  701.                                     ┬º┬ºgoto(addr776);
  702.                                  }
  703.                               }
  704.                               set("\x01",eval("\x01") - 6);
  705.                               stop();
  706.                               delete this.onEnterFrame;
  707.                               break loop0;
  708.                            }
  709.                            set("\x01",eval("\x01") + 224);
  710.                            if(┬º┬ºpop())
  711.                            {
  712.                               set("\x01",eval("\x01") + 123);
  713.                            }
  714.                         }
  715.                      }
  716.                      ┬º┬ºgoto(addr776);
  717.                   }
  718.                   ┬º┬ºgoto(addr1087);
  719.                }
  720.             }
  721.             else
  722.             {
  723.                if(eval("\x01") == 325)
  724.                {
  725.                   set("\x01",eval("\x01") + 552);
  726.                   if(┬º┬ºpop())
  727.                   {
  728.                      set("\x01",eval("\x01") - 521);
  729.                   }
  730.                   addr1568:
  731.                   while(true)
  732.                   {
  733.                      if(eval("\x01") == 346)
  734.                      {
  735.                         set("\x01",eval("\x01") + 86);
  736.                         ┬º┬ºpush(true);
  737.                         continue;
  738.                      }
  739.                      if(eval("\x01") == 551)
  740.                      {
  741.                         set("\x01",eval("\x01") + 320);
  742.                         continue;
  743.                      }
  744.                      if(eval("\x01") == 141)
  745.                      {
  746.                         set("\x01",eval("\x01") + 47);
  747.                         ┬º┬ºpush(true);
  748.                         continue;
  749.                      }
  750.                      if(eval("\x01") == 977)
  751.                      {
  752.                         set("\x01",eval("\x01") - 80);
  753.                         continue;
  754.                      }
  755.                      if(eval("\x01") == 971)
  756.                      {
  757.                         set("\x01",eval("\x01") - 793);
  758.                         if(┬º┬ºpop())
  759.                         {
  760.                            set("\x01",eval("\x01") + 329);
  761.                         }
  762.                         continue;
  763.                      }
  764.                      if(eval("\x01") == 805)
  765.                      {
  766.                         set("\x01",eval("\x01") - 662);
  767.                         continue;
  768.                      }
  769.                      if(eval("\x01") == 209)
  770.                      {
  771.                         set("\x01",eval("\x01") + 425);
  772.                         break loop0;
  773.                      }
  774.                      if(eval("\x01") == 472)
  775.                      {
  776.                         set("\x01",eval("\x01") + 355);
  777.                         if(┬º┬ºpop())
  778.                         {
  779.                            set("\x01",eval("\x01") + 150);
  780.                         }
  781.                         continue;
  782.                      }
  783.                      if(eval("\x01") == 6)
  784.                      {
  785.                         set("\x01",eval("\x01") + 203);
  786.                         if(┬º┬ºpop())
  787.                         {
  788.                            set("\x01",eval("\x01") + 425);
  789.                         }
  790.                         continue;
  791.                      }
  792.                      if(eval("\x01") == 123)
  793.                      {
  794.                         set("\x01",eval("\x01") + 20);
  795.                         continue;
  796.                      }
  797.                      if(eval("\x01") == 634)
  798.                      {
  799.                         set("\x01",eval("\x01") - 493);
  800.                         continue;
  801.                      }
  802.                      if(eval("\x01") == 508)
  803.                      {
  804.                         set("\x01",eval("\x01") + 47);
  805.                         nextFrame();
  806.                         ┬º┬ºgoto(addr304);
  807.                      }
  808.                      else
  809.                      {
  810.                         if(eval("\x01") == 188)
  811.                         {
  812.                            set("\x01",eval("\x01") + 320);
  813.                            if(┬º┬ºpop())
  814.                            {
  815.                               set("\x01",eval("\x01") + 47);
  816.                            }
  817.                            continue;
  818.                         }
  819.                         if(eval("\x01") == 921)
  820.                         {
  821.                            set("\x01",eval("\x01") - 780);
  822.                            continue;
  823.                         }
  824.                         if(eval("\x01") == 490)
  825.                         {
  826.                            set("\x01",eval("\x01") - 411);
  827.                            break loop0;
  828.                         }
  829.                         if(eval("\x01") == 396)
  830.                         {
  831.                            set("\x01",eval("\x01") + 190);
  832.                            if(┬º┬ºpop())
  833.                            {
  834.                               set("\x01",eval("\x01") + 371);
  835.                            }
  836.                            continue;
  837.                         }
  838.                         if(eval("\x01") == 24)
  839.                         {
  840.                            set("\x01",eval("\x01") + 456);
  841.                            continue;
  842.                         }
  843.                         if(eval("\x01") == 286)
  844.                         {
  845.                            set("\x01",eval("\x01") - 280);
  846.                            ┬º┬ºpush(true);
  847.                            continue;
  848.                         }
  849.                         if(eval("\x01") == 555)
  850.                         {
  851.                            set("\x01",eval("\x01") + 316);
  852.                            continue;
  853.                         }
  854.                         if(eval("\x01") == 238)
  855.                         {
  856.                            set("\x01",eval("\x01") + 733);
  857.                            ┬º┬ºpush(true);
  858.                            continue;
  859.                         }
  860.                         if(eval("\x01") == 516)
  861.                         {
  862.                            set("\x01",eval("\x01") - 44);
  863.                            ┬º┬ºpush(true);
  864.                            continue;
  865.                         }
  866.                         if(eval("\x01") != 102)
  867.                         {
  868.                            if(eval("\x01") != 871)
  869.                            {
  870.                               break;
  871.                            }
  872.                            set("\x01",eval("\x01") - 546);
  873.                            ┬º┬ºpush(true);
  874.                            continue;
  875.                         }
  876.                         set("\x01",eval("\x01") + 703);
  877.                         ┬º┬ºgoto(addr1440);
  878.                      }
  879.                   }
  880.                   continue;
  881.                   addr1568:
  882.                }
  883.                else
  884.                {
  885.                   if(eval("\x01") == 432)
  886.                   {
  887.                      set("\x01",eval("\x01") - 330);
  888.                      if(┬º┬ºpop())
  889.                      {
  890.                         set("\x01",eval("\x01") + 703);
  891.                      }
  892.                   }
  893.                   else if(eval("\x01") == 106)
  894.                   {
  895.                      set("\x01",eval("\x01") + 318);
  896.                   }
  897.                   else
  898.                   {
  899.                      if(eval("\x01") == 877)
  900.                      {
  901.                         set("\x01",eval("\x01") - 521);
  902.                         break loop0;
  903.                      }
  904.                      if(eval("\x01") == 143)
  905.                      {
  906.                         set("\x01",eval("\x01") + 548);
  907.                         ┬º┬ºgoto(addr1568);
  908.                         ┬º┬ºpush(true);
  909.                      }
  910.                      else
  911.                      {
  912.                         if(eval("\x01") == 480)
  913.                         {
  914.                            set("\x01",eval("\x01") - 84);
  915.                            ┬º┬ºgoto(addr1568);
  916.                            ┬º┬ºpush(true);
  917.                         }
  918.                         else
  919.                         {
  920.                            if(eval("\x01") == 356)
  921.                            {
  922.                               set("\x01",eval("\x01") + 124);
  923.                            }
  924.                            else
  925.                            {
  926.                               if(eval("\x01") == 586)
  927.                               {
  928.                                  set("\x01",eval("\x01") + 371);
  929.                                  ┬º┬ºpush(┬º┬ºpop().substr(┬º┬ºpop(),┬º┬ºpop()));
  930.                                  break loop0;
  931.                               }
  932.                               if(eval("\x01") == 691)
  933.                               {
  934.                                  set("\x01",eval("\x01") - 201);
  935.                                  if(┬º┬ºpop())
  936.                                  {
  937.                                     set("\x01",eval("\x01") - 411);
  938.                                  }
  939.                               }
  940.                               else if(eval("\x01") == 507)
  941.                               {
  942.                                  set("\x01",eval("\x01") - 221);
  943.                               }
  944.                               else
  945.                               {
  946.                                  if(eval("\x01") == 178)
  947.                                  {
  948.                                     set("\x01",eval("\x01") + 329);
  949.                                     set(┬º┬ºpop(),eval(┬º┬ºpop()) - 415);
  950.                                     break loop0;
  951.                                  }
  952.                                  if(eval("\x01") == 718)
  953.                                  {
  954.                                     set("\x01",eval("\x01") - 480);
  955.                                  }
  956.                                  else if(eval("\x01") == 424)
  957.                                  {
  958.                                     set("\x01",eval("\x01") + 351);
  959.                                     ┬º┬ºgoto(addr1568);
  960.                                     ┬º┬ºpush(true);
  961.                                  }
  962.                                  else
  963.                                  {
  964.                                     if(eval("\x01") == 79)
  965.                                     {
  966.                                        set("\x01",eval("\x01") + 159);
  967.                                     }
  968.                                     else if(eval("\x01") == 775)
  969.                                     {
  970.                                        set("\x01",eval("\x01") + 181);
  971.                                        if(┬º┬ºpop())
  972.                                        {
  973.                                           set("\x01",eval("\x01") - 551);
  974.                                        }
  975.                                     }
  976.                                     else if(eval("\x01") == 405)
  977.                                     {
  978.                                        set("\x01",eval("\x01") + 111);
  979.                                     }
  980.                                     else if(eval("\x01") == 650)
  981.                                     {
  982.                                        set("\x01",eval("\x01") - 134);
  983.                                     }
  984.                                     else
  985.                                     {
  986.                                        if(eval("\x01") == 827)
  987.                                        {
  988.                                           set("\x01",eval("\x01") + 150);
  989.                                           ┬º┬ºpush(┬º┬ºpop() instanceof typeof ┬º┬ºpop());
  990.                                           break loop0;
  991.                                        }
  992.                                        if(eval("\x01") != 329)
  993.                                        {
  994.                                           if(eval("\x01") == 897)
  995.                                           {
  996.                                              set("\x01",eval("\x01") - 812);
  997.                                              stop();
  998.                                              delete this.onEnterFrame;
  999.                                              break loop0;
  1000.                                           }
  1001.                                           if(eval("\x01") == 85)
  1002.                                           {
  1003.                                              set("\x01",eval("\x01") - 85);
  1004.                                           }
  1005.                                           break loop0;
  1006.                                        }
  1007.                                        set("\x01",eval("\x01") + 568);
  1008.                                     }
  1009.                                     ┬º┬ºgoto(addr1568);
  1010.                                  }
  1011.                               }
  1012.                            }
  1013.                            ┬º┬ºgoto(addr1568);
  1014.                         }
  1015.                         ┬º┬ºgoto(addr1568);
  1016.                      }
  1017.                   }
  1018.                   ┬º┬ºgoto(addr1568);
  1019.                }
  1020.                ┬º┬ºgoto(addr1568);
  1021.             }
  1022.             ┬º┬ºgoto(addr1440);
  1023.          }
  1024.          ┬º┬ºgoto(addr1568);
  1025.       }
  1026.    }
  1027.    else
  1028.    {
  1029.       if(eval("\x01") == 298)
  1030.       {
  1031.          set("\x01",eval("\x01") + 352);
  1032.          if(┬º┬ºpop())
  1033.          {
  1034.             set("\x01",eval("\x01") + 153);
  1035.          }
  1036.          continue;
  1037.       }
  1038.       if(eval("\x01") == 177)
  1039.       {
  1040.          set("\x01",eval("\x01") + 8);
  1041.          break;
  1042.       }
  1043.       if(eval("\x01") == 794)
  1044.       {
  1045.          set("\x01",eval("\x01") + 115);
  1046.          continue;
  1047.       }
  1048.       if(eval("\x01") == 803)
  1049.       {
  1050.          set("\x01",eval("\x01") - 760);
  1051.          continue;
  1052.       }
  1053.       if(eval("\x01") == 660)
  1054.       {
  1055.          set("\x01",eval("\x01") - 483);
  1056.          if(┬º┬ºpop())
  1057.          {
  1058.             set("\x01",eval("\x01") + 8);
  1059.          }
  1060.          continue;
  1061.       }
  1062.       if(eval("\x01") == 989)
  1063.       {
  1064.          set("\x01",eval("\x01") - 80);
  1065.          continue;
  1066.       }
  1067.       if(eval("\x01") == 135)
  1068.       {
  1069.          set("\x01",eval("\x01") + 723);
  1070.          stop();
  1071.          break;
  1072.       }
  1073.       if(eval("\x01") == 251)
  1074.       {
  1075.          set("\x01",eval("\x01") - 116);
  1076.          continue;
  1077.       }
  1078.       if(eval("\x01") == 43)
  1079.       {
  1080.          set("\x01",eval("\x01") + 546);
  1081.          ┬º┬ºpush(true);
  1082.          continue;
  1083.       }
  1084.       if(eval("\x01") != 308)
  1085.       {
  1086.          if(eval("\x01") == 589)
  1087.          {
  1088.             set("\x01",eval("\x01") - 281);
  1089.             if(┬º┬ºpop())
  1090.             {
  1091.                set("\x01",eval("\x01") + 681);
  1092.             }
  1093.          }
  1094.          else if(eval("\x01") == 282)
  1095.          {
  1096.             set("\x01",eval("\x01") - 147);
  1097.          }
  1098.          else if(eval("\x01") == 774)
  1099.          {
  1100.             set("\x01",eval("\x01") - 731);
  1101.          }
  1102.          else if(eval("\x01") == 728)
  1103.          {
  1104.             set("\x01",eval("\x01") - 332);
  1105.             ┬º┬ºpush(true);
  1106.          }
  1107.          else
  1108.          {
  1109.             if(eval("\x01") == 650)
  1110.             {
  1111.                set("\x01",eval("\x01") + 153);
  1112.                break;
  1113.             }
  1114.             if(eval("\x01") == 858)
  1115.             {
  1116.                set("\x01",eval("\x01") - 858);
  1117.                break;
  1118.             }
  1119.             if(eval("\x01") != 185)
  1120.             {
  1121.                break;
  1122.             }
  1123.             set("\x01",eval("\x01") + 543);
  1124.          }
  1125.          continue;
  1126.       }
  1127.       set("\x01",eval("\x01") + 681);
  1128.    }
  1129.    ┬º┬ºgoto(addr1089);
  1130. }
  1131.